#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""数据同步器模块
负责市场数据的同步和管理"""

import time
import threading
from datetime import datetime
from utils import Logger

class DataSynchronizer:
    """数据同步器
    负责从API获取市场数据并同步到本地"""
    
    def __init__(self):
        """初始化数据同步器"""
        # 同步配置
        self.sync_interval = 60  # 默认同步间隔(秒)
        self.last_sync_time = None
        
        # 同步状态和线程锁
        self.is_syncing = False
        self.sync_thread = None
        self._sync_lock = threading.Lock()  # 添加线程锁以确保同步操作的线程安全
        self._stop_event = threading.Event()  # 用于通知线程停止的事件
        
        # 数据缓存
        self.market_data_cache = {}
        self.stock_data_cache = {}
        self.industry_data_cache = {}
        
        Logger.log_info("数据同步器初始化完成")
        
    def sync_market_data(self, stock_codes):
        """同步市场数据
        
        Args:
            stock_codes: 股票代码列表
            
        Returns:
            dict: 同步的市场数据，以股票代码为键
        """
        # 尝试获取线程锁，如果无法获取（已有线程在同步），则直接返回空字典
        if not self._sync_lock.acquire(blocking=False):
            Logger.log_info("数据同步已经在进行中，跳过本次请求")
            return {}
        
        try:
            # 只有成功获取锁的线程才能执行同步操作
            Logger.log_info(f"开始同步指定股票数据: {stock_codes}")
            
            # 模拟数据同步过程
            time.sleep(0.5)  # 减少睡眠时间以提高测试效率
            
            # 模拟返回的市场数据
            market_data = {}
            for code in stock_codes:
                stock_info = {
                    "code": code,
                    "name": f"股票{code}",
                    "price": 100.0,
                    "volume": 100000,
                    "timestamp": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
                }
                market_data[code] = stock_info
            
            # 更新数据缓存
            self.market_data_cache.update(market_data)
            
            # 更新同步时间
            self.last_sync_time = datetime.now()
            
            Logger.log_info(f"市场数据同步完成，同步股票数量: {len(market_data)}")
            return market_data
        except Exception as e:
            Logger.log_error(f"同步市场数据失败: {str(e)}")
            return {}
        finally:
            # 确保无论如何都会释放锁
            self._sync_lock.release()
            
    def start_auto_sync(self, interval=None, stock_codes=None):
        """启动自动同步
        
        Args:
            interval: 同步间隔(秒)
            stock_codes: 要同步的股票代码列表，默认为None表示不指定特定股票
        """
        if interval:
            self.sync_interval = interval
            
        if self.sync_thread and self.sync_thread.is_alive():
            Logger.log_info("自动同步已经在运行中")
            return
            
        # 重置停止事件
        self._stop_event.clear()
            
        # 如果没有指定股票代码，使用一个默认的股票代码列表
        if stock_codes is None:
            stock_codes = []
            
        Logger.log_info(f"启动自动同步，间隔: {self.sync_interval}秒，股票数量: {len(stock_codes)}")
        
        def sync_task():
            while not self._stop_event.is_set():
                try:
                    if stock_codes:
                        self.sync_market_data(stock_codes)
                    else:
                        Logger.log_info("自动同步: 没有指定股票代码，跳过本次同步")
                    # 使用wait方法并检查事件状态，这样可以在设置事件时立即唤醒线程
                    self._stop_event.wait(self.sync_interval)
                except Exception as e:
                    Logger.log_error(f"自动同步任务异常: {str(e)}")
                    # 发生异常时，短暂暂停后继续，但仍然检查停止事件
                    self._stop_event.wait(10)
        
        self.sync_thread = threading.Thread(target=sync_task, daemon=True)
        self.sync_thread.start()
        
    def stop_auto_sync(self):
        """停止自动同步"""
        if self.sync_thread and self.sync_thread.is_alive():
            # 设置停止事件
            self._stop_event.set()
            # 等待线程结束（最多等待2秒）
            self.sync_thread.join(timeout=2.0)
            Logger.log_info("已停止自动同步")
        else:
            Logger.log_info("自动同步未运行")
    
    def get_stock_data(self, stock_code):
        """获取股票数据
        
        Args:
            stock_code: 股票代码
            
        Returns:
            dict: 股票数据或None
        """
        if stock_code in self.stock_data_cache:
            return self.stock_data_cache[stock_code]
        
        # 不再返回模拟数据，只返回None
        Logger.log_warning(f"数据同步器不再提供模拟数据: {stock_code}")
        return None
    
    def clear_cache(self):
        """清理缓存数据"""
        self.market_data_cache.clear()
        self.stock_data_cache.clear()
        self.industry_data_cache.clear()
        Logger.log_info("数据缓存已清理")